செயல்திறனைத் திறத்தல்: இணையான செயலாக்கத்தின் மூலம் பல-கோர் CPU பயன்பாடு

இன்றைய கணினி உலகில், பல-கோர் CPUs எங்கும் நிறைந்திருக்கின்றன. ஸ்மார்ட்போன்கள் முதல் சேவையகங்கள் வரை, இந்த செயலிகள் குறிப்பிடத்தக்க செயல்திறன் ஆதாயங்களுக்கான திறனை வழங்குகின்றன. இருப்பினும், இந்த திறனை உணர்ந்து கொள்வதற்கு, இணையான செயலாக்கம் மற்றும் பல கோர்களை ஒரே நேரத்தில் எவ்வாறு திறம்படப் பயன்படுத்துவது என்பது பற்றிய உறுதியான புரிதல் தேவைப்படுகிறது. இந்த வழிகாட்டி, டெவலப்பர்கள் மற்றும் கணினி நிர்வாகிகள் அனைவருக்கும் ஏற்ற வகையில், இணையான செயலாக்கத்தின் மூலம் பல-கோர் CPU பயன்பாட்டின் முழுமையான கண்ணோட்டத்தை வழங்குவதை நோக்கமாகக் கொண்டுள்ளது, அத்தியாவசிய கருத்துக்கள், நுட்பங்கள் மற்றும் நடைமுறை எடுத்துக்காட்டுகளை உள்ளடக்கியுள்ளது.

பல-கோர் CPUs-ஐப் புரிந்துகொள்வது

ஒரு பல-கோர் CPU என்பது அடிப்படையில் பல சுயாதீன செயலாக்க அலகுகள் (கோர்கள்) ஒரு தனி இயற்பியல் சிப்பில் ஒருங்கிணைக்கப்பட்டுள்ளன. ஒவ்வொரு கோரும் சுயாதீனமாக வழிமுறைகளை இயக்க முடியும், இது CPU ஒரே நேரத்தில் பல பணிகளைச் செய்ய அனுமதிக்கிறது. ஒரே நேரத்தில் ஒரு வழிமுறையை மட்டுமே இயக்கக்கூடிய ஒற்றை-கோர் செயலிகளிலிருந்து இது ஒரு குறிப்பிடத்தக்க வேறுபாடாகும். CPU-இல் உள்ள கோர்களின் எண்ணிக்கை அதன் இணையான பணிச்சுமைகளை கையாளும் திறனுக்கு ஒரு முக்கிய காரணியாகும். பொதுவான உள்ளமைவுகளில் இரட்டை-கோர், குவாட்-கோர், ஹெக்ஸா-கோர் (6 கோர்கள்), ஆக்டா-கோர் (8 கோர்கள்) மற்றும் சேவையகம் மற்றும் உயர்-செயல்திறன் கணினி சூழல்களில் அதிக கோர் எண்ணிக்கைகள் ஆகியவை அடங்கும்.

பல-கோர் CPUs-இன் நன்மைகள்

• அதிகரித்த உற்பத்தித்திறன்: பல-கோர் CPUs ஒரே நேரத்தில் அதிக பணிகளை செயலாக்க முடியும், இது ஒட்டுமொத்த உற்பத்தித்திறனை அதிகரிக்கும்.
• மேம்படுத்தப்பட்ட பதில்: பல கோர்களில் பணிகளை விநியோகிப்பதன் மூலம், அதிக சுமையின் கீழும் கூட பயன்பாடுகள் பதிலளிக்கக்கூடியதாக இருக்கும்.
• மேம்படுத்தப்பட்ட செயல்திறன்: இணையான செயலாக்கம் கணக்கீட்டு ரீதியாக தீவிரமான பணிகளின் இயக்க நேரத்தை கணிசமாகக் குறைக்கும்.
• ஆற்றல் திறன்: சில சந்தர்ப்பங்களில், பல பணிகளை ஒரே நேரத்தில் பல கோர்களில் இயக்குவது ஒரு கோரில் அவற்றை வரிசையாக இயக்குவதை விட ஆற்றல் திறன் மிக்கதாக இருக்கும்.

இணையான செயலாக்க கருத்துக்கள்

இணையான செயலாக்கம் என்பது பல வழிமுறைகள் ஒரே நேரத்தில் செயல்படுத்தப்படும் ஒரு கணினி முன்னுதாரணமாகும். வழிமுறைகள் ஒன்றன்பின் ஒன்றாக செயல்படுத்தப்படும் வரிசைமுறை செயலாக்கத்துடன் இது வேறுபடுகிறது. இணையான செயலாக்கத்தில் பல வகைகள் உள்ளன, ஒவ்வொன்றும் அதன் சொந்த பண்புகளையும் பயன்பாடுகளையும் கொண்டுள்ளன.

இணையானத்தின் வகைகள்

• தரவு இணையான தன்மை: ஒரே செயல்பாடு பல தரவு கூறுகளில் ஒரே நேரத்தில் செய்யப்படுகிறது. இது பட செயலாக்கம், அறிவியல் உருவகப்படுத்துதல் மற்றும் தரவு பகுப்பாய்வு போன்ற பணிகளுக்கு மிகவும் பொருத்தமானது. எடுத்துக்காட்டாக, ஒரு படத்தில் உள்ள ஒவ்வொரு பிக்சலுக்கும் ஒரே வடிகட்டியைப் பயன்படுத்துவதை இணையான முறையில் செய்யலாம்.
• பணி இணையான தன்மை: வெவ்வேறு பணிகள் ஒரே நேரத்தில் செய்யப்படுகின்றன. பணிச்சுமையை சுயாதீன பணிகளாகப் பிரிக்கக்கூடிய பயன்பாடுகளுக்கு இது பொருத்தமானது. எடுத்துக்காட்டாக, ஒரு வலை சேவையகம் பல கிளையன்ட் கோரிக்கைகளை ஒரே நேரத்தில் கையாள முடியும்.
• வழிமுறை-நிலை இணையான தன்மை (ILP): இது CPU ஆல் பயன்படுத்தப்படும் ஒரு வகை இணையான தன்மை ஆகும். நவீன CPUs குழாய் மற்றும் ஒழுங்கற்ற-வரிசை செயல்படுத்தல் போன்ற நுட்பங்களைப் பயன்படுத்தி ஒரு கோருக்குள் பல வழிமுறைகளை ஒரே நேரத்தில் இயக்குகின்றன.

ஒருங்கிசைவு மற்றும் இணையான தன்மை

ஒருங்கிசைவு மற்றும் இணையான தன்மைக்கு இடையே வேறுபடுத்துவது முக்கியம். ஒருங்கிசைவு என்பது பல பணிகளை ஒரே நேரத்தில் கையாளுவதற்கான ஒரு அமைப்பின் திறன் ஆகும். இணையான தன்மை என்பது பல பணிகளின் உண்மையான ஒரே நேரத்தில் செயல்படுத்தல் ஆகும். ஒரு ஒற்றை-கோர் CPU, நேர-பகிர்வு போன்ற நுட்பங்கள் மூலம் ஒருங்கிசைவைப் பெற முடியும், ஆனால் அது உண்மையான இணையான தன்மையை அடைய முடியாது. பல-கோர் CPUs பல பணிகளை ஒரே நேரத்தில் வெவ்வேறு கோர்களில் இயக்க அனுமதிப்பதன் மூலம் உண்மையான இணையான தன்மையை செயல்படுத்துகின்றன.

ஆம்தாலின் விதி மற்றும் கஸ்டாஃப்ஸனின் விதி

ஆம்தாலின் விதி மற்றும் கஸ்டாஃப்ஸனின் விதி ஆகியவை இணையான தன்மையின் மூலம் செயல்திறன் மேம்பாட்டின் வரம்புகளை நிர்வகிக்கும் இரண்டு அடிப்படை கொள்கைகளாகும். திறமையான இணையான வழிமுறைகளை வடிவமைப்பதற்கு இந்த விதிகளைப் புரிந்துகொள்வது முக்கியம்.

ஆம்தாலின் விதி

ஒரு நிரலை இணையான முறையில் பயன்படுத்துவதன் மூலம் அடையக்கூடிய அதிகபட்ச வேகம், நிரலின் வரிசை முறையில் செயல்படுத்தப்பட வேண்டிய பகுதியால் கட்டுப்படுத்தப்படுகிறது என்று ஆம்தாலின் விதி கூறுகிறது. ஆம்தாலின் விதியின் சூத்திரம்:

வேகம் = 1 / (S + (P / N))

எங்கே:

• S என்பது நிரலின் வரிசை முறை (இணையான முறையில் செய்ய முடியாது) ஆகும்.
• P என்பது நிரலின் இணையான முறையில் செய்யக்கூடிய பகுதி (P = 1 - S).
• N என்பது செயலிகளின் (கோர்கள்) எண்ணிக்கை.

இணையான தன்மையின் மூலம் குறிப்பிடத்தக்க வேகத்தை அடைய, ஒரு நிரலின் வரிசைப் பகுதியை குறைப்பதன் முக்கியத்துவத்தை ஆம்தாலின் விதி எடுத்துக்காட்டுகிறது. எடுத்துக்காட்டாக, ஒரு நிரலில் 10% வரிசைமுறை இருந்தால், செயலிகளின் எண்ணிக்கையைப் பொருட்படுத்தாமல் அடையக்கூடிய அதிகபட்ச வேகம் 10x ஆகும்.

கஸ்டாஃப்ஸனின் விதி

கஸ்டாஃப்ஸனின் விதி இணையான தன்மை பற்றி ஒரு வித்தியாசமான கண்ணோட்டத்தை வழங்குகிறது. செயலாக்கிகளின் எண்ணிக்கை அதிகரிக்கும்போது இணையான முறையில் செய்யக்கூடிய வேலையின் அளவு அதிகரிக்கிறது என்று அது கூறுகிறது. கஸ்டாஃப்ஸனின் விதியின் சூத்திரம்:

வேகம் = S + P * N

எங்கே:

• S என்பது நிரலின் வரிசை முறை ஆகும்.
• P என்பது நிரலின் இணையான முறையில் செய்யக்கூடிய பகுதி (P = 1 - S).
• N என்பது செயலிகளின் (கோர்கள்) எண்ணிக்கை.

பிரச்சனையின் அளவு அதிகரிக்கும்போது, ​​நிரலின் இணையான முறையில் செய்யக்கூடிய பகுதியும் அதிகரிக்கிறது, இது அதிக செயலிகளில் சிறந்த வேகத்தை ஏற்படுத்தும் என்று கஸ்டாஃப்ஸனின் விதி கூறுகிறது. இது பெரிய அளவிலான அறிவியல் உருவகப்படுத்துதல் மற்றும் தரவு பகுப்பாய்வு பணிகளுக்கு குறிப்பாக பொருத்தமானது.

முக்கிய குறிப்பு: ஆம்தாலின் விதி நிலையான பிரச்சினை அளவை மையப்படுத்துகிறது, அதே நேரத்தில் கஸ்டாஃப்ஸனின் விதி செயலிகளின் எண்ணிக்கையுடன் பிரச்சினை அளவை அளவிடுவதற்கு கவனம் செலுத்துகிறது.

பல-கோர் CPU பயன்பாட்டிற்கான நுட்பங்கள்

பல-கோர் CPUs-ஐ திறம்படப் பயன்படுத்துவதற்கு பல நுட்பங்கள் உள்ளன. இந்த நுட்பங்கள் பணிச்சுமையை சிறிய பணிகளாகப் பிரிப்பதை உள்ளடக்கியது, அவை இணையான முறையில் செயல்படுத்தப்படலாம்.

திரெட்டிங்

திரெட்டிங் என்பது ஒரு செயல்முறையினுள் பல இயக்க திரெட்களை உருவாக்கும் நுட்பமாகும். ஒவ்வொரு திரெடும் சுதந்திரமாக செயல்படுத்த முடியும், இது செயல்முறை பல பணிகளை ஒரே நேரத்தில் செய்ய அனுமதிக்கிறது. திரெட்கள் ஒரே நினைவக இடத்தைப் பகிர்ந்து கொள்கின்றன, இது தொடர்பு கொள்ளவும் தரவைப் பகிர்ந்து கொள்ளவும் அனுமதிக்கிறது. இருப்பினும், இந்த பகிரப்பட்ட நினைவக இடம் பந்தய நிலைகள் மற்றும் பிற ஒத்திசைவு சிக்கல்களின் அபாயத்தை அறிமுகப்படுத்துகிறது, இதற்கு கவனமாக நிரலாக்கம் தேவைப்படுகிறது.

திரெட்டிங்கின் நன்மைகள்

• வளங்களைப் பகிர்வது: திரெட்கள் ஒரே நினைவக இடத்தைப் பகிர்ந்து கொள்கின்றன, இது தரவு பரிமாற்றத்தின் மேலோட்டத்தைக் குறைக்கிறது.
• எடை குறைந்தது: திரெட்கள் பொதுவாக செயல்முறைகளை விட இலகுவானவை, இது அவற்றை உருவாக்குவதற்கும், மாற்றுவதற்கும் வேகமாக்குகிறது.
• மேம்படுத்தப்பட்ட பதில்: பின்னணி பணிகளைச் செய்யும் போது பயனர் இடைமுகத்தை பதிலளிக்கக்கூடியதாக வைத்திருக்க திரெட்களைப் பயன்படுத்தலாம்.

திரெட்டிங்கின் தீமைகள்

• ஒத்திசைவு சிக்கல்கள்: ஒரே நினைவகத்தைப் பகிர்ந்து கொள்ளும் திரெட்கள் பந்தய நிலைகள் மற்றும் டெட்லாக்களுக்கு வழிவகுக்கும்.
• பிழைத்திருத்த சிக்கல்: பல-திரெட்டட் பயன்பாடுகளுக்கு பிழைத்திருத்துவது ஒற்றை-திரெட்டட் பயன்பாடுகளுக்கு பிழைத்திருத்துவதை விட சவாலாக இருக்கலாம்.
• குளோபல் இன்டர்ப்ரிட்டர் லாக் (GIL): பைத்தான் போன்ற சில மொழிகளில், குளோபல் இன்டர்ப்ரிட்டர் லாக் (GIL) திரெட்களின் உண்மையான இணையான தன்மையை வரம்பிடுகிறது, ஏனெனில் ஒரு திரெட் மட்டுமே எந்த நேரத்திலும் பைத்தான் இன்டர்ப்ரிட்டரின் கட்டுப்பாட்டை வைத்திருக்க முடியும்.

திரெட்டிங் லைப்ரரி

பெரும்பாலான நிரலாக்க மொழிகள் திரெட்களை உருவாக்குவதற்கும், நிர்வகிப்பதற்கும் நூலகங்களை வழங்குகின்றன. எடுத்துக்காட்டுகள் பின்வருமாறு:

• POSIX திரெட்கள் (pthreads): Unix போன்ற அமைப்புகளுக்கான ஒரு நிலையான திரெட்டிங் API.
• விண்டோஸ் திரெட்கள்: விண்டோஸிற்கான சொந்த திரெட்டிங் API.
• ஜாவா திரெட்கள்: ஜாவாவில் உள்ள திரெட்டிங் ஆதரவு.
• .NET திரெட்கள்: .NET கட்டமைப்பில் திரெட்டிங் ஆதரவு.
• பைத்தான் திரெட்டிங் தொகுதி: பைத்தானில் ஒரு உயர்-நிலை திரெட்டிங் இடைமுகம் (CPU-க்குட்பட்ட பணிகளுக்கான GIL வரம்புகளுக்கு உட்பட்டது).

மல்டிபிராசஸிங்

மல்டிபிராசஸிங் என்பது பல செயல்முறைகளை உருவாக்குவதை உள்ளடக்கியது, ஒவ்வொன்றும் அதன் சொந்த நினைவக இடத்தைக் கொண்டுள்ளன. இது GIL-இன் வரம்புகள் அல்லது பகிரப்பட்ட நினைவக மோதல்களின் ஆபத்து இல்லாமல், செயல்முறைகளை உண்மையில் இணையான முறையில் செயல்படுத்த அனுமதிக்கிறது. இருப்பினும், செயல்முறைகள் திரெட்களை விட கனமானவை, மேலும் செயல்முறைகளுக்கு இடையிலான தொடர்பு மிகவும் சிக்கலானது.

மல்டிபிராசஸிங்கின் நன்மைகள்

• உண்மையான இணையான தன்மை: செயல்முறைகள் உண்மையில் இணையான முறையில் இயக்க முடியும், GIL உடன் மொழிகளிலும் கூட.
• தனிமை: செயல்முறைகள் அவற்றின் சொந்த நினைவக இடத்தைக் கொண்டுள்ளன, இது மோதல்கள் மற்றும் செயலிழப்புகளின் அபாயத்தைக் குறைக்கிறது.
• அளவிடக்கூடிய தன்மை: மல்டிபிராசஸிங் அதிக எண்ணிக்கையிலான கோர்களுக்கு நன்றாக அளவிட முடியும்.

மல்டிபிராசஸிங்கின் தீமைகள்

• மேலோட்டம்: செயல்முறைகள் திரெட்களை விட கனமானவை, இதனால் அவற்றை உருவாக்குவதற்கும், மாற்றுவதற்கும் மெதுவாக இருக்கும்.
• தொடர்பு சிக்கல்: செயல்முறைகளுக்கு இடையிலான தொடர்பு திரெட்களுக்கு இடையிலான தொடர்புகளை விட சிக்கலானது.
• வள நுகர்வு: செயல்முறைகள் திரெட்களை விட அதிக நினைவகம் மற்றும் பிற வளங்களைப் பயன்படுத்துகின்றன.

மல்டிபிராசஸிங் லைப்ரரி

பெரும்பாலான நிரலாக்க மொழிகள் செயல்முறைகளை உருவாக்குவதற்கும் நிர்வகிப்பதற்கும் நூலகங்களையும் வழங்குகின்றன. எடுத்துக்காட்டுகள் பின்வருமாறு:

• பைத்தான் மல்டிபிராசஸிங் தொகுதி: பைத்தானில் செயல்முறைகளை உருவாக்குவதற்கும் நிர்வகிப்பதற்கும் ஒரு சக்திவாய்ந்த தொகுதி.
• ஜாவா ProcessBuilder: ஜாவாவில் வெளிப்புற செயல்முறைகளை உருவாக்குவதற்கும் நிர்வகிப்பதற்கும்.
• C++ fork() மற்றும் exec(): C++ இல் செயல்முறைகளை உருவாக்குவதற்கும் செயல்படுத்துவதற்குமான கணினி அழைப்புகள்.

OpenMP

OpenMP (Open Multi-Processing) என்பது பகிரப்பட்ட-நினைவக இணையான நிரலாக்கத்திற்கான ஒரு API ஆகும். இது C, C++, மற்றும் Fortran நிரல்களை இணையான முறையில் செயல்படுத்த பயன்படுத்தக்கூடிய தொகுப்பி கட்டளைகள், நூலக வழக்கங்கள் மற்றும் சுற்றுச்சூழல் மாறிகளின் தொகுப்பை வழங்குகிறது. OpenMP குறிப்பாக தரவு-இணையான பணிகளுக்கு, அதாவது லூப் இணையான தன்மைக்கு மிகவும் பொருத்தமானது.

OpenMP-இன் நன்மைகள்

• பயன்படுத்துவது எளிது: OpenMP ஒப்பீட்டளவில் பயன்படுத்த எளிதானது, குறியீட்டை இணையான முறையில் செயல்படுத்த சில தொகுப்பி கட்டளைகள் மட்டுமே தேவைப்படுகின்றன.
• போர்ட்டபிளிட்டி: OpenMP பெரும்பாலான முக்கிய தொகுப்பிகள் மற்றும் இயக்க முறைமைகளால் ஆதரிக்கப்படுகிறது.
• வளர்ச்சி இணையான தன்மை: முழு பயன்பாட்டையும் மீண்டும் எழுதாமல், குறியீட்டை படிப்படியாக இணையான முறையில் செயல்படுத்த OpenMP உங்களை அனுமதிக்கிறது.

OpenMP-இன் தீமைகள்

• பகிரப்பட்ட நினைவக கட்டுப்பாடு: OpenMP பகிரப்பட்ட-நினைவக அமைப்புகளுக்காக வடிவமைக்கப்பட்டுள்ளது மற்றும் விநியோகிக்கப்பட்ட-நினைவக அமைப்புகளுக்கு ஏற்றதல்ல.
• ஒத்திசைவு மேலோட்டம்: கவனமாக நிர்வகிக்காவிட்டால் ஒத்திசைவு மேலோட்டம் செயல்திறனைக் குறைக்கலாம்.

MPI (செய்தி கடத்தும் இடைமுகம்)

MPI (செய்தி கடத்தும் இடைமுகம்) என்பது செயல்முறைகளுக்கு இடையே செய்தி-கடத்தும் தொடர்புகளுக்கான ஒரு தரநிலையாகும். இது கிளஸ்டர்கள் மற்றும் சூப்பர் கம்ப்யூட்டர்கள் போன்ற விநியோகிக்கப்பட்ட-நினைவக அமைப்புகளில் இணையான நிரலாக்கத்திற்கு பரவலாகப் பயன்படுத்தப்படுகிறது. MPI செயல்முறைகள் செய்திகளை அனுப்புதல் மற்றும் பெறுவதன் மூலம் தங்கள் வேலையைத் தொடர்பு கொள்ளவும் ஒருங்கிணைக்கவும் அனுமதிக்கிறது.

MPI-இன் நன்மைகள்

• அளவிடக்கூடிய தன்மை: MPI விநியோகிக்கப்பட்ட-நினைவக அமைப்புகளில் அதிக எண்ணிக்கையிலான செயலிகளுக்கு அளவிட முடியும்.
• நெகிழ்வுத்தன்மை: சிக்கலான இணையான வழிமுறைகளை செயல்படுத்தப் பயன்படுத்தக்கூடிய பணிகளின் ஒரு பணக்கார தொகுப்பை MPI வழங்குகிறது.

MPI-இன் தீமைகள்

• சிக்கலானது: MPI நிரலாக்கம் பகிரப்பட்ட-நினைவக நிரலாக்கத்தை விட சிக்கலானதாக இருக்கலாம்.
• தொடர்பு மேலோட்டம்: MPI பயன்பாடுகளின் செயல்திறனில் தொடர்பு மேலோட்டம் ஒரு முக்கிய காரணியாக இருக்கலாம்.

நடைமுறை எடுத்துக்காட்டுகளும் குறியீடு துணுக்குகளும்

மேலே விவாதிக்கப்பட்ட கருத்துகளை விளக்குவதற்கு, பல்வேறு நிரலாக்க மொழிகளில் சில நடைமுறை எடுத்துக்காட்டுகளையும் குறியீடு துணுக்குகளையும் கருத்தில் கொள்வோம்.

பைத்தான் மல்டிபிராசஸிங் எடுத்துக்காட்டு

இந்த எடுத்துக்காட்டு, பைத்தானில் உள்ள மல்டிபிராசஸிங் தொகுதியைப் பயன்படுத்தி, இணையான முறையில் எண்களின் பட்டியலின் வர்க்கங்களின் கூட்டுத்தொகையை எவ்வாறு கணக்கிடுவது என்பதை விளக்குகிறது.

import multiprocessing
import time

def square_sum(numbers):
  """எண்களின் பட்டியலின் வர்க்கங்களின் கூட்டுத்தொகையை கணக்கிடுகிறது."""
  total = 0
  for n in numbers:
    total += n * n
  return total

if __name__ == '__main__':
  numbers = list(range(1, 1001))
  num_processes = multiprocessing.cpu_count()  # CPU கோர்களின் எண்ணிக்கையைப் பெறுங்கள்
  chunk_size = len(numbers) // num_processes
  chunks = [numbers[i:i + chunk_size] for i in range(0, len(numbers), chunk_size)]

  with multiprocessing.Pool(processes=num_processes) as pool:
    start_time = time.time()
    results = pool.map(square_sum, chunks)
    end_time = time.time()

  total_sum = sum(results)
  print(f"வர்க்கங்களின் மொத்த தொகை: {total_sum}")
  print(f"செயல்படுத்தும் நேரம்: {end_time - start_time:.4f} வினாடிகள்")

இந்த எடுத்துக்காட்டு எண்களின் பட்டியலை துண்டுகளாகப் பிரித்து, ஒவ்வொரு துண்டும் ஒரு தனி செயல்முறைக்கு ஒதுக்கப் படுகிறது. மல்டிபிராசஸிங்.பூல் வகுப்பு செயல்முறைகளை உருவாக்குதல் மற்றும் செயல்படுத்துவதை நிர்வகிக்கிறது.

ஜாவா ஒருங்கிசைவு எடுத்துக்காட்டு

இணைந்த முறையில் ஒரு ஒத்த பணியைச் செய்ய ஜாவாவின் ஒருங்கிசைவு API-ஐ எவ்வாறு பயன்படுத்துவது என்பதை இந்த எடுத்துக்காட்டு விளக்குகிறது.

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class SquareSumTask implements Callable {
  private final List numbers;

  public SquareSumTask(List numbers) {
    this.numbers = numbers;
  }

  @Override
  public Long call() {
    long total = 0;
    for (int n : numbers) {
      total += n * n;
    }
    return total;
  }

  public static void main(String[] args) throws Exception {
    List numbers = new ArrayList<>();
    for (int i = 1; i <= 1000; i++) {
      numbers.add(i);
    }

    int numThreads = Runtime.getRuntime().availableProcessors(); // CPU கோர்களின் எண்ணிக்கையைப் பெறுங்கள்
    ExecutorService executor = Executors.newFixedThreadPool(numThreads);

    int chunkSize = numbers.size() / numThreads;
    List> futures = new ArrayList<>();

    for (int i = 0; i < numThreads; i++) {
      int start = i * chunkSize;
      int end = (i == numThreads - 1) ? numbers.size() : (i + 1) * chunkSize;
      List chunk = numbers.subList(start, end);
      SquareSumTask task = new SquareSumTask(chunk);
      futures.add(executor.submit(task));
    }

    long totalSum = 0;
    for (Future future : futures) {
      totalSum += future.get();
    }

    executor.shutdown();

    System.out.println("வர்க்கங்களின் மொத்த தொகை: " + totalSum);
  }
}

இந்த எடுத்துக்காட்டு திரெட்களின் ஒரு தொகுப்பை நிர்வகிக்க ஒரு ExecutorService ஐப் பயன்படுத்துகிறது. ஒவ்வொரு திரெட்டும் எண்களின் பட்டியலில் ஒரு பகுதியின் வர்க்கங்களின் கூட்டுத்தொகையை கணக்கிடுகிறது. Future இடைமுகம், நீங்கள் ஒத்திசைவற்ற பணிகளின் முடிவுகளைப் பெற அனுமதிக்கிறது.

C++ OpenMP எடுத்துக்காட்டு

C++ இல் ஒரு லூப்பை இணையான முறையில் செயல்படுத்த OpenMP ஐ எவ்வாறு பயன்படுத்துவது என்பதை இந்த எடுத்துக்காட்டு விளக்குகிறது.

#include 
#include 
#include 
#include 

int main() {
  int n = 1000;
  std::vector numbers(n);
  std::iota(numbers.begin(), numbers.end(), 1);

  long long total_sum = 0;

  #pragma omp parallel for reduction(+:total_sum)
  for (int i = 0; i < n; ++i) {
    total_sum += (long long)numbers[i] * numbers[i];
  }

  std::cout << "வர்க்கங்களின் மொத்த தொகை: " << total_sum << std::endl;

  return 0;
}

#pragma omp parallel for கட்டளை, லூப்பை இணையான முறையில் செயல்படுத்த தொகுப்பிக்கு சொல்கிறது. reduction(+:total_sum) விதியை, total_sum மாறி அனைத்து திரெட்களிலும் குறைக்கப்பட வேண்டும் என்று குறிப்பிடுகிறது, இது இறுதி முடிவு சரியாக இருப்பதை உறுதி செய்கிறது.

CPU பயன்பாட்டை கண்காணிப்பதற்கான கருவிகள்

உங்கள் பயன்பாடுகள் பல-கோர் CPUs-ஐ எவ்வளவு சிறப்பாகப் பயன்படுத்துகின்றன என்பதைப் புரிந்துகொள்ள, CPU பயன்பாட்டை கண்காணிப்பது அவசியம். வெவ்வேறு இயக்க முறைமைகளில் CPU பயன்பாட்டை கண்காணிக்க பல கருவிகள் கிடைக்கின்றன.

• லினக்ஸ்: top, htop, vmstat, iostat, perf
• விண்டோஸ்: பணி மேலாளர், வள கண்காணிப்பு, செயல்திறன் கண்காணிப்பு
• macOS: செயல்பாடு கண்காணிப்பு, top

இந்த கருவிகள் CPU பயன்பாடு, நினைவக பயன்பாடு, வட்டு I/O மற்றும் பிற கணினி அளவீடுகள் பற்றிய தகவல்களை வழங்குகின்றன. இவை செயல்தடைகளை அடையாளம் காணவும், சிறந்த செயல்திறனுக்காக உங்கள் பயன்பாடுகளை மேம்படுத்தவும் உதவும்.

பல-கோர் CPU பயன்பாட்டிற்கான சிறந்த நடைமுறைகள்

பல-கோர் CPUs-ஐ திறம்படப் பயன்படுத்த, பின்வரும் சிறந்த நடைமுறைகளைக் கவனியுங்கள்:

• இணையான முறையில் செய்யக்கூடிய பணிகளை அடையாளம் காணுதல்: இணையான முறையில் செயல்படுத்தக்கூடிய பணிகளை அடையாளம் காண, உங்கள் பயன்பாட்டைப் பகுப்பாய்வு செய்யுங்கள்.
• சரியான நுட்பத்தைத் தேர்ந்தெடுங்கள்: பணி மற்றும் கணினி கட்டமைப்பின் பண்புகளின் அடிப்படையில், பொருத்தமான இணையான நிரலாக்க நுட்பத்தை (திரெட்டிங், மல்டிபிராசஸிங், OpenMP, MPI) தேர்ந்தெடுக்கவும்.
• ஒத்திசைவு மேலோட்டத்தை குறைக்கவும்: திரெட்கள் அல்லது செயல்முறைகளுக்கு இடையே தேவையான ஒத்திசைவின் அளவைக் குறைக்கவும்.
• பொய்யான பகிர்வைத் தவிர்க்கவும்: திரெட்கள் ஒரே கேச் கோட்டில் இருக்கும் வெவ்வேறு தரவு பொருட்களை அணுகும் ஒரு நிகழ்வைப் பற்றி அறிந்திருங்கள், இது தேவையற்ற கேச் செல்லாததாக்குதல் மற்றும் செயல்திறன் குறைவதற்கு வழிவகுக்கும்.
• பணிச்சுமையை சமநிலைப்படுத்துங்கள்: எந்த கோரும் செயலற்று இருக்காமல், மற்றவை அதிக சுமையாக இல்லாமல் இருப்பதை உறுதிசெய்ய, பணிச்சுமையை அனைத்து கோர்களிலும் சமமாக விநியோகிக்கவும்.
• செயல்திறனை கண்காணிக்கவும்: செயல்தடைகளை அடையாளம் காணவும், உங்கள் பயன்பாட்டை மேம்படுத்தவும், CPU பயன்பாடு மற்றும் பிற செயல்திறன் அளவீடுகளை தொடர்ந்து கண்காணிக்கவும்.
• ஆம்தாலின் விதி மற்றும் கஸ்டாஃப்ஸனின் விதியைக் கவனியுங்கள்: உங்கள் குறியீட்டின் வரிசைப் பகுதியின் அடிப்படையில் மற்றும் உங்கள் பிரச்சினை அளவின் அளவிடக்கூடியதன் அடிப்படையில் வேகத்தின் தத்துவார்த்த வரம்புகளைப் புரிந்து கொள்ளுங்கள்.
• புரோபைலிங் கருவிகளைப் பயன்படுத்துங்கள்: உங்கள் குறியீட்டில் செயல்திறன் தடைகள் மற்றும் ஹாட்ஸ்பாட்களை அடையாளம் காண, புரோபைலிங் கருவிகளைப் பயன்படுத்தவும். எடுத்துக்காட்டுகளில் Intel VTune Amplifier, perf (Linux) மற்றும் Xcode Instruments (macOS) ஆகியவை அடங்கும்.

உலகளாவிய பரிசீலனைகள் மற்றும் சர்வதேசமயமாக்கல்

ஒரு உலகளாவிய பார்வையாளர்களுக்காக பயன்பாடுகளை உருவாக்கும்போது, ​​சர்வதேசமயமாக்கல் மற்றும் உள்ளூர்மயமாக்கலைக் கருத்தில் கொள்வது அவசியம். இதில் பின்வருவன அடங்கும்:

• எழுத்து குறியீட்டு முறை: பரந்த அளவிலான எழுத்துகளை ஆதரிக்க யூனிகோட் (UTF-8) பயன்படுத்தவும்.
• உள்ளூர்மயமாக்கல்: வெவ்வேறு மொழிகள், பிராந்தியங்கள் மற்றும் கலாச்சாரங்களுக்கு பயன்பாட்டை மாற்றியமைக்கவும்.
• நேர மண்டலங்கள்: வெவ்வேறு இடங்களில் உள்ள பயனர்களுக்கு தேதிகளும் நேரங்களும் துல்லியமாக காண்பிக்கப்படுவதை உறுதி செய்ய, நேர மண்டலங்களை சரியாகக் கையாளவும்.
• நாணயம்: பல நாணயங்களை ஆதரிக்கவும், நாணய சின்னங்களை தகுந்தவாறு காட்டவும்.
• எண் மற்றும் தேதி வடிவங்கள்: வெவ்வேறு இடங்களுக்கு பொருத்தமான எண் மற்றும் தேதி வடிவங்களைப் பயன்படுத்தவும்.

உங்கள் பயன்பாடுகள் உலகளவில் பயனர்களால் அணுகக்கூடியதாகவும், பயன்படுத்தக்கூடியதாகவும் இருப்பதை உறுதி செய்வதற்கு இந்த பரிசீலனைகள் முக்கியமானவை.

முடிவுரை

பல-கோர் CPUs, இணையான செயலாக்கத்தின் மூலம் குறிப்பிடத்தக்க செயல்திறன் ஆதாயங்களுக்கான திறனை வழங்குகின்றன. இந்த வழிகாட்டியில் விவாதிக்கப்பட்ட கருத்துகள் மற்றும் நுட்பங்களைப் புரிந்துகொள்வதன் மூலம், டெவலப்பர்கள் மற்றும் கணினி நிர்வாகிகள் தங்கள் பயன்பாடுகளின் செயல்திறன், பதில் மற்றும் அளவிடக்கூடிய தன்மையை மேம்படுத்த பல-கோர் CPUs-ஐ திறம்படப் பயன்படுத்த முடியும். சரியான இணையான நிரலாக்க மாதிரியைத் தேர்ந்தெடுப்பதில் இருந்து, CPU பயன்பாட்டை கவனமாக கண்காணிப்பதற்கும், உலகளாவிய காரணிகளைக் கருத்தில் கொள்வதற்கும், இன்றைய மாறுபட்ட மற்றும் தேவைப்படும் கணினிச் சூழல்களில் பல-கோர் செயலிகளின் முழு திறனையும் திறப்பதற்கான ஒரு முழுமையான அணுகுமுறை அவசியம். உண்மையான உலக செயல்திறன் தரவின் அடிப்படையில், உங்கள் குறியீட்டைத் தொடர்ந்து சுயவிவரப்படுத்தி, மேம்படுத்தவும், மேலும் இணையான செயலாக்க தொழில்நுட்பங்களில் சமீபத்திய முன்னேற்றங்கள் பற்றி அறிந்து கொள்ளுங்கள்.